// // // // #include <iostream> 

// // // // class BASE{ 
// // // //     char b; 
// // // // public: 
// // // //     BASE(char n):b(n){} 
// // // //     ~BASE(){std::cout<<b;} 
// // // // }; 
// // // // class DERIVED:public BASE{ 
// // // //     char d; 
// // // // public: 
// // // //     DERIVED(char n):BASE(n+1),d(n){} 
// // // //     ~DERIVED(){std::cout<<d;} 
// // // // }; 

// // // // int main(){ 
// // // //     DERIVED a('X'); 
// // // //     return 0; 
// // // // }
// // // #include <iostream>

// // // class BASE {
// // //     char b;
// // // public:
// // //     BASE(char n) : b(n) {}
// // //     ~BASE() { std::cout << "BASE destructor: " << b << std::endl; } // 非虚析构函数
// // // };

// // // class DERIVED : public BASE {
// // //     char d;
// // // public:
// // //     DERIVED(char n) : BASE(n + 1), d(n) {}
// // //     ~DERIVED() { std::cout << "DERIVED destructor: " << d << std::endl; }
// // // };

// // // int main() {
// // //     BASE* ptr = new DERIVED('X'); // 基类指针指向派生类对象
// // //     delete ptr; // 通过基类指针删除派生类对象
// // //     return 0;
// // // }


// // #include <iostream>
// // void asd(int a=12,int b=34){
// //     std::cout<<a<<","<<b<<std::endl;
// // }
// // int main(){
// //     asd();
// //     asd(6);
// //     asd(7,8);
// //     asd(54);
// //     return 0;
// // }
// #include <iostream>
// using std::cout; 
// using std::endl; 
// class B{ 
// public: 
//  B(int a0=0, int b0=0):a(a0), b(b0){}
// int AR()const{return a*b;} 
// bool operator < (const B& b){ 
//  return AR() < b.AR(); 
//  }
//  bool operator == (const B& b){
//     return AR() == b.AR(); 
//     } 
//    bool operator == (int n){ 
//     return AR() == n; 
//     } 
//    private: 
//    int a, b; 
//    };

//    template <typename T>
// T* bs( T* a, int n, const T& k){ 
// int b = 0, e = n-1, m; 
// while(b <= e){ 
//  m = (b+e)/2; 
//  if(a[m] == k) break; 
//  else if (a[m] < k) b = m+1; 
//  else e = m-1; 
//  } 
// if(b <= e)return &a[m];
// else 
//  return NULL; 
// } 
// int main() 
// { 
//  B b[]={B(1,2), B(3,4), B(5,6)}; 
//  B* k = bs(b, 3, B(2,6)); 
// if(k != NULL) 
//  cout << k->AR() << endl; 
// else 
//  cout << "Can not find." << endl; 
// return 0; 
// }

#include <iostream>
#include <string>
class BASE { 
public:
   std::string name;
   std::string sex;
   
   BASE(std::string n, std::string s) : name(n), sex(s) {}
   BASE() : name(""),sex(""){}
   // virtual 
   void print() { 
      std::cout << "Name: " << name << std::endl; 
      std::cout << "Sex: " << sex << std::endl; 
   }
};
class DERIVED : public BASE { 
public: 
   std::string birth; 

   DERIVED(std::string n, std::string s, std::string b):birth(b){
      BASE::name=n+"(student)";
      BASE::sex=s+"(student)";
   }
   // virtual 
   void print(){ 
      BASE::print();

      std::cout << "Birth: " << birth << std::endl; 
   }
};

class derived2 : public DERIVED {
   std::string grade;
public:
   derived2(std::string n, std::string s, std::string b, std::string g):DERIVED(n,s,b){
      grade=g;
   }
   void print(){
      DERIVED::print();
      std::cout << "Grade: " << grade << std::endl; 
   }
};
int main() {
   derived2* p = new derived2("asd","male","2000-01-01","97");
   p->print();
   return 0;
}